学习笔记

主题

2026-07-31

19-DI Container（7）：如何实现Field Injection部分的功能？ ​

你好，我是徐昊。今天我们继续使用TDD的方式实现注入依赖容器。

回顾代码与任务列表 ​

到目前为止，我们的代码是这样的：

ContextConfig.java:

package geektime.tdd.di;

import java.util.*;
import static java.util.List.of;

public class ContextConfig {
    private Map<Class<?>, ComponentProvider<?>> providers = new HashMap<>();
    
    public <Type> void bind(Class<Type> type, Type instance) {
        providers.put(type, new ComponentProvider<Type>() {
            @Override
            public Type get(Context context) {
                return instance;
            }
            @Override
            public List<Class<?>> getDependencies() {
                return of();
            }
        });
    }
    
    public <Type, Implementation extends Type>
    void bind(Class<Type> type, Class<Implementation> implementation) {
        providers.put(type, new ConstructorInjectionProvider<>(implementation));
    }
    
    public Context getContext() {
        providers.keySet().forEach(component -> checkDependencies(component, new Stack<>()));
        return new Context() {
            @Override
            public <Type> Optional<Type> get(Class<Type> type) {
                return Optional.ofNullable(providers.get(type)).map(provider -> (Type) provider.get(this));
            }
        };
    }
    
    private void checkDependencies(Class<?> component, Stack<Class<?>> visiting) {
        for (Class<?> dependency: providers.get(component).getDependencies()) {
            if (!providers.containsKey(dependency)) throw new DependencyNotFoundException(component, dependency);
            if (visiting.contains(dependency)) throw new CyclicDependenciesFoundException(visiting);
            visiting.push(dependency);
            checkDependencies(dependency, visiting);
            visiting.pop();
        }
    }
    
    interface ComponentProvider<T> {
        T get(Context context);
        List<Class<?>> getDependencies();
    }
}
    
ConstructorInjectionProvider.java:
    
package geektime.tdd.di;
    
import jakarta.inject.Inject;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Parameter;
import java.util.List;
import java.util.stream.Collectors;
import static java.util.Arrays.stream;


class ConstructorInjectionProvider<T> implements ContextConfig.ComponentProvider<T> {
    private Constructor<T> injectConstructor;
    
    public ConstructorInjectionProvider(Class<T> component) {
        this.injectConstructor = getInjectConstructor(component);
    }
    
    private static <Type> Constructor<Type> getInjectConstructor(Class<Type> implementation) {
        List<Constructor<?>> injectConstructors = stream(implementation.getConstructors())
                .filter(c -> c.isAnnotationPresent(Inject.class)).collect(Collectors.toList());
        if (injectConstructors.size() > 1) throw new IllegalComponentException();
        return (Constructor<Type>) injectConstructors.stream().findFirst().orElseGet(() -> {
            try {
                return implementation.getConstructor();
            } catch (NoSuchMethodException e) {
                throw new IllegalComponentException();
            }
        });
    }
    
    @Override
    public T get(Context context) {
        try {
            Object[] dependencies = stream(injectConstructor.getParameters())
                    .map(p -> context.get(p.getType()).get())
                    .toArray(Object[]::new);
            return injectConstructor.newInstance(dependencies);
        } catch (InvocationTargetException | InstantiationException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
    
    @Override
    public List<Class<?>> getDependencies() {
        return stream(injectConstructor.getParameters()).map(Parameter::getType).collect(Collectors.toList());
    }
}
    
Context.java:
package geektime.tdd.di;
    
import java.util.Optional;
    
public interface Context {
    <Type> Optional<Type> get(Class<Type> type);
}

任务列表状态为：

  • 无需构造的组件——组件实例

  • 如果注册的组件不可实例化，则抛出异常

    • 抽象类
    • 接口

  • 构造函数注入

    • 无依赖的组件应该通过默认构造函数生成组件实例
    • 有依赖的组件，通过Inject标注的构造函数生成组件实例
    • 如果所依赖的组件也存在依赖，那么需要对所依赖的组件也完成依赖注入
    • 如果组件有多于一个Inject标注的构造函数，则抛出异常
    • 如果组件没有Inject标注的构造函数，也没有默认构造函数（新增任务）
    • 如果组件需要的依赖不存在，则抛出异常
    • 如果组件间存在循环依赖，则抛出异常

  • 字段注入

    • 通过Inject标注将字段声明为依赖组件
    • 如果组件需要的依赖不存在，则抛出异常
    • 如果字段为final则抛出异常
    • 如果组件间存在循环依赖，则抛出异常

  • 方法注入

    • 通过Inject标注的方法，其参数为依赖组件
    • 通过Inject标注的无参数方法，会被调用
    • 按照子类中的规则，覆盖父类中的Inject方法
    • 如果组件需要的依赖不存在，则抛出异常
    • 如果方法定义类型参数，则抛出异常
    • 如果组件间存在循环依赖，则抛出异常

  • 对Provider类型的依赖

    • 注入构造函数中可以声明对于Provider的依赖
    • 注入字段中可以声明对于Provider的依赖
    • 注入方法中可声明对于Provider的依赖

  • 自定义Qualifier的依赖

    • 注册组件时，可额外指定Qualifier
    • 注册组件时，可从类对象上提取Qualifier
    • 寻找依赖时，需同时满足类型与自定义Qualifier标注
    • 支持默认Qualifier——Named

  • Singleton生命周期

    • 注册组件时，可额外指定是否为Singleton
    • 注册组件时，可从类对象上提取Singleton标注
    • 对于包含Singleton标注的组件，在容器范围内提供唯一实例
    • 容器组件默认不是Single生命周期

  • 自定义Scope标注

    • 可向容器注册自定义Scope标注的回调

视频演示 ​

让我们进入今天的部分：

思考题 ​

在进入下节课之前，希望你能认真思考如下两个问题，并选择最有感触的一道进行回答。

  1. 要如何实现Method Injection部分的功能呢？
  2. 在你看来，这节课的难易程度如何？有遇到什么卡壳的地方吗？

欢迎把你的想法分享在留言区，也欢迎把你的项目代码的链接分享出来。相信经过你的思考与实操，学习效果会更好！

最近更新